Agents e Tool Use

1 O que são Agents?

De assistentes que respondem para assistentes que agem.

LLM tradicional vs Agent

Usuário: "Qual o clima amanhã?"
LLM: "Não tenho acesso a dados em tempo real."

Usuário: "Qual o clima amanhã?"
Agent: [Busca API de clima] → "Amanhã: 25°C, sol."

As 3 capacidades de um Agent

2 Function Calling — LLMs executando código

Como fazer o modelo chamar funções Python, APIs e ferramentas externas.

🎮 Simulador: Agent decidindo qual ferramenta usar

Clique em cada etapa para ver o raciocínio do agente.

Exemplo: Function Calling com Ollama

import ollama
import json

# Define as ferramentas disponíveis
tools = [
    {
        'type': 'function',
        'function': {
            'name': 'buscar_clima',
            'description': 'Busca a previsão do tempo para uma cidade',
            'parameters': {
                'type': 'object',
                'properties': {
                    'cidade': {
                        'type': 'string',
                        'description': 'Nome da cidade'
                    }
                },
                'required': ['cidade']
            }
        }
    },
    {
        'type': 'function',
        'function': {
            'name': 'buscar_ticket',
            'description': 'Busca informações de um ticket de suporte',
            'parameters': {
                'type': 'object',
                'properties': {
                    'ticket_id': {
                        'type': 'string',
                        'description': 'ID do ticket'
                    }
                },
                'required': ['ticket_id']
            }
        }
    }
]

# Funções reais que serão executadas
def buscar_clima(cidade):
    # Aqui você chamaria uma API real de clima
    return {"cidade": cidade, "temp": "25°C", "condicao": "sol"}

def buscar_ticket(ticket_id):
    # Aqui você buscaria no banco de dados
    return {"id": ticket_id, "status": "resolvido", "solucao": "timeout aumentado"}

# Usuário faz pergunta
mensagem = "Qual o clima em Porto Alegre e o status do ticket #4521?"

# Chama LLM com ferramentas
response = ollama.chat(
    model='llama3.1:8b',
    messages=[{'role': 'user', 'content': mensagem}],
    tools=tools
)

# LLM decide quais ferramentas chamar
if response.message.tool_calls:
    for tool_call in response.message.tool_calls:
        if tool_call.function.name == 'buscar_clima':
            args = json.loads(tool_call.function.arguments)
            resultado = buscar_clima(args['cidade'])
            print(f"Clima: {resultado}")
        elif tool_call.function.name == 'buscar_ticket':
            args = json.loads(tool_call.function.arguments)
            resultado = buscar_ticket(args['ticket_id'])
            print(f"Ticket: {resultado}")

Ferramentas comuns para Agents

3 ReAct — Raciocinar + Agir

O loop de decisão que faz agents pensarem antes de agir.

O loop ReAct

Exemplo de prompt ReAct

# Prompt estruturado para ReAct
REACT_PROMPT = """Você é um assistente que resolve tarefas passo a passo.

Para cada passo, você deve:
1. PENSAR sobre o que fazer a seguir
2. AGIR chamando uma ferramenta (se necessário)
3. OBSERVAR o resultado da ação
4. REPETIR até ter informação suficiente para responder

Ferramentas disponíveis:
- buscar_nfs(mes, ano): busca notas fiscais
- calcular_soma(valores): soma uma lista de números
- buscar_ticket(ticket_id): busca informações de um ticket

Tarefa: {tarefa}

PENSAMENTO 1:"""

# LLM gera raciocínio estruturado
# PENSAMENTO 1: Preciso buscar as NFs de junho primeiro.
# AÇÃO 1: buscar_nfs(mes="junho", ano=2025)
# OBSERVAÇÃO 1: [lista de NFs]
# PENSAMENTO 2: Agora preciso somar os valores.
# AÇÃO 2: calcular_soma([48500, 12300, 8200])
# OBSERVAÇÃO 2: 69000
# RESPOSTA FINAL: O valor total é R$ 69.000,00.

4 Multi-Agent Systems

Vários agents colaborando para resolver problemas complexos.

🎮 Visualização: Equipe de Agents

Clique em cada agent para ver sua especialidade.

Frameworks populares

Exemplo: CrewAI para análise de documentos

from crewai import Agent, Task, Crew

# Define agents especializados
pesquisador = Agent(
    role="Pesquisador de Documentos",
    goal="Encontrar informações relevantes nos documentos",
    backstory="Especialista em buscar e extrair informações de documentos",
    tools=[buscar_documento, extrair_texto],
    verbose=True
)

analista = Agent(
    role="Analista de Dados",
    goal="Analisar as informações encontradas e identificar padrões",
    backstory="Especialista em análise de dados e identificação de tendências",
    tools=[analisar_dados, criar_grafico],
    verbose=True
)

redator = Agent(
    role="Redator de Relatórios",
    goal="Criar relatórios claros e bem estruturados",
    backstory="Especialista em comunicação técnica e redação de relatórios",
    tools=[escrever_relatorio, formatar_documento],
    verbose=True
)

# Define tarefas
tarefa_pesquisa = Task(
    description="Buscar todas as notas fiscais de equipamentos de rede em 2025",
    agent=pesquisador,
    expected_output="Lista de NFs com valores e datas"
)

tarefa_analise = Task(
    description="Analisar os gastos com equipamentos de rede e identificar tendências",
    agent=analista,
    expected_output="Análise de gastos com gráficos e insights"
)

tarefa_relatorio = Task(
    description="Criar um relatório executivo sobre os gastos com equipamentos de rede",
    agent=redator,
    expected_output="Relatório PDF com análise e recomendações"
)

# Cria crew e executa
crew = Crew(
    agents=[pesquisador, analista, redator],
    tasks=[tarefa_pesquisa, tarefa_analise, tarefa_relatorio],
    verbose=True
)

resultado = crew.kickoff()
print(resultado)

5 Agentic RAG

O agent decide quando buscar, o que buscar e se precisa buscar mais.

RAG tradicional vs Agentic RAG

Exemplo: Agent decidindo quando buscar mais

# Agentic RAG com LangGraph
from langgraph.graph import StateGraph, END
from typing import TypedDict

class AgentState(TypedDict):
    question: str
    context: str
    iterations: int
    answer: str

def decide_search_strategy(state: AgentState):
    # Agent pensa em como buscar
    return {
        "search_query": reformulate_query(state["question"])
    }

def search_documents(state: AgentState):
    # Busca chunks
    chunks = vector_db.search(state["search_query"], top_k=5)
    return {"context": format_context(chunks)}

def evaluate_sufficiency(state: AgentState):
    # Agent avalia se informação é suficiente
    evaluation = llm.invoke(f"""
    Pergunta: {state['question']}
    Contexto: {state['context']}
    
    A informação no contexto é suficiente para responder a pergunta?
    Responda SIM ou NÃO.
    """)
    
    if "SIM" in evaluation:
        return {"sufficient": True}
    else:
        return {"sufficient": False, "iterations": state["iterations"] + 1}

def generate_answer(state: AgentState):
    # Gera resposta final
    answer = llm.invoke(f"""
    Com base no contexto, responda a pergunta.
    Pergunta: {state['question']}
    Contexto: {state['context']}
    """)
    return {"answer": answer}

# Constrói grafo
workflow = StateGraph(AgentState)
workflow.add_node("decide", decide_search_strategy)
workflow.add_node("search", search_documents)
workflow.add_node("evaluate", evaluate_sufficiency)
workflow.add_node("answer", generate_answer)

workflow.add_edge("decide", "search")
workflow.add_edge("search", "evaluate")

# Condicional: se suficiente, responde; senão, busca de novo
workflow.add_conditional_edges(
    "evaluate",
    lambda x: "answer" if x["sufficient"] or x["iterations"] >= 3 else "decide"
)

workflow.set_entry_point("decide")
app = workflow.compile()

# Executa
result = app.invoke({
    "question": "Qual o timeout do endpoint /v2/sync?",
    "context": "",
    "iterations": 0,
    "answer": ""
})

print(result["answer"])

Vantagens do Agentic RAG

6 Casos de uso práticos

Onde agents brilham — e onde não fazem sentido.

Quando usar Agents

Quando NÃO usar Agents

Exemplo: Agent para suporte técnico da Nimbus Cloud

# Agent que resolve tickets de suporte
class SupportAgent:
    def __init__(self):
        self.tools = {
            "buscar_ticket": self.buscar_ticket,
            "buscar_documentacao": self.buscar_documentacao,
            "executar_comando": self.executar_comando,
            "atualizar_ticket": self.atualizar_ticket
        }
    
    def resolver_ticket(self, ticket_id):
        # 1. Busca informações do ticket
        ticket = self.buscar_ticket(ticket_id)
        
        # 2. Agent pensa na estratégia
        pensamento = llm.invoke(f"""
        Ticket: {ticket}
        
        Como resolver este problema?
        1. Preciso buscar documentação?
        2. Preciso executar algum comando?
        3. Preciso de mais informações do usuário?
        """)
        
        # 3. Executa ações baseado no raciocínio
        if "documentação" in pensamento:
            docs = self.buscar_documentacao(ticket["problema"])
            # ... continua raciocinando
        
        # 4. Atualiza ticket com solução
        self.atualizar_ticket(ticket_id, solucao)
        
        return solucao

7 Desafios e limitações

O que pode dar errado — e como mitigar.

Melhores práticas

8 Conexão com RAG e próximos passos

Como agents evoluem o RAG — e o que vem depois.

Evolução: LLM → RAG → Agent

O que vem depois?

🎯 Quiz — teste seu conhecimento

Clique em uma alternativa para ver se acertou.

→ O que vem a seguir?

Agora que você entende agents, vamos adicionar visão, áudio e vídeo ao sistema.

Conceitos que vamos construir aqui